﻿using ReflectionStudio.Core.Events;
using System;
using System.ComponentModel;
using System.Data;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using WPFExcelReport.Helpers;
using System.Windows.Threading;
namespace WPFExcelReport
{
    public partial class UITXTKON : ViewBase
    {
        public int TPCount = 10;
        public VTXTKON TMV
        {
            get
            {
                return (VTXTKON)MV;
            }
        }

        #region ==IsTXTBox===========
        public static readonly DependencyProperty IsTXTBoxProperty = DependencyProperty.Register("IsTXTBox",
            typeof(bool), typeof(UITXTKON),
            new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnIsTXTBoxChanged));
        public bool IsTXTBox
        {
            get
            {
                return (bool)GetValue(IsTXTBoxProperty);
            }
            set
            {
                SetValue(IsTXTBoxProperty, value);
                if (TMV == null)
                    return;
                TMV.IsTXTBox = value;
            }
        }
        private static void OnIsTXTBoxChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.IsTXTBox = (bool)e.NewValue;
            }
        }
        #endregion
        #region ==IsL1===========
        public static readonly DependencyProperty IsL1Property = DependencyProperty.Register("IsL1",
            typeof(bool), typeof(UITXTKON),
            new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnIsL1Changed));
        public bool IsL1
        {
            get
            {
                return (bool)GetValue(IsL1Property);
            }
            set
            {
                SetValue(IsL1Property, value);
            }
        }
        private static void OnIsL1Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.IsL1 = (bool)e.NewValue;
            }
        }
        #endregion

        #region ==IsL2===========
        public static readonly DependencyProperty IsL2Property = DependencyProperty.Register("IsL2",
            typeof(bool), typeof(UITXTKON),
            new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnIsL2Changed));
        public bool IsL2
        {
            get
            {
                return (bool)GetValue(IsL2Property);
            }
            set
            {
                SetValue(IsL2Property, value);
            }
        }
        private static void OnIsL2Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.IsL2 = (bool)e.NewValue;
            }
        }
        #endregion

        #region ==IsL3===========
        public static readonly DependencyProperty IsL3Property = DependencyProperty.Register("IsL3",
            typeof(bool), typeof(UITXTKON),
            new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnIsL3Changed));
        public bool IsL3
        {
            get
            {
                return (bool)GetValue(IsL3Property);
            }
            set
            {
                SetValue(IsL3Property, value);
            }
        }
        private static void OnIsL3Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.IsL3 = (bool)e.NewValue;
            }
        }
        #endregion

        #region ==IsL4===========
        public static readonly DependencyProperty IsL4Property = DependencyProperty.Register("IsL4",
            typeof(bool), typeof(UITXTKON),
            new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnIsL4Changed));
        public bool IsL4
        {
            get
            {
                return (bool)GetValue(IsL4Property);
            }
            set
            {
                SetValue(IsL4Property, value);
            }
        }
        private static void OnIsL4Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.IsL4 = (bool)e.NewValue;
            }
        }
        #endregion

        #region ==IsL5===========
        public static readonly DependencyProperty IsL5Property = DependencyProperty.Register("IsL5",
            typeof(bool), typeof(UITXTKON),
            new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnIsL5Changed));
        public bool IsL5
        {
            get
            {
                return (bool)GetValue(IsL5Property);
            }
            set
            {
                SetValue(IsL5Property, value);
            }
        }
        private static void OnIsL5Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.IsL5 = (bool)e.NewValue;
            }
        }
        #endregion

        #region ==IsL6===========
        public static readonly DependencyProperty IsL6Property = DependencyProperty.Register("IsL6",
            typeof(bool), typeof(UITXTKON),
            new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnIsL6Changed));
        public bool IsL6
        {
            get
            {
                return (bool)GetValue(IsL6Property);
            }
            set
            {
                SetValue(IsL6Property, value);
            }
        }
        private static void OnIsL6Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.IsL6 = (bool)e.NewValue;
            }
        }
        #endregion

        #region ==IsL7===========
        public static readonly DependencyProperty IsL7Property = DependencyProperty.Register("IsL7",
            typeof(bool), typeof(UITXTKON),
            new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnIsL7Changed));
        public bool IsL7
        {
            get
            {
                return (bool)GetValue(IsL7Property);
            }
            set
            {
                SetValue(IsL7Property, value);
            }
        }
        private static void OnIsL7Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.IsL7 = (bool)e.NewValue;
            }
        }
        #endregion

        #region ==IsL8===========
        public static readonly DependencyProperty IsL8Property = DependencyProperty.Register("IsL8",
            typeof(bool), typeof(UITXTKON),
            new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnIsL8Changed));
        public bool IsL8
        {
            get
            {
                return (bool)GetValue(IsL8Property);
            }
            set
            {
                SetValue(IsL8Property, value);
            }
        }
        private static void OnIsL8Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.IsL8 = (bool)e.NewValue;
            }
        }
        #endregion

        #region ==IsL9===========
        public static readonly DependencyProperty IsL9Property = DependencyProperty.Register("IsL9",
            typeof(bool), typeof(UITXTKON),
            new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnIsL9Changed));
        public bool IsL9
        {
            get
            {
                return (bool)GetValue(IsL9Property);
            }
            set
            {
                SetValue(IsL9Property, value);
            }
        }
        private static void OnIsL9Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.IsL9 = (bool)e.NewValue;
            }
        }
        #endregion

        #region ==IsInfoOneLine===========
        public static readonly DependencyProperty IsInfoOneLineProperty = DependencyProperty.Register("IsInfoOneLine",
            typeof(bool), typeof(UITXTKON),
            new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnIsInfoOneLineChanged));
        public bool IsInfoOneLine
        {
            get
            {
                return (bool)GetValue(IsInfoOneLineProperty);
            }
            set
            {
                SetValue(IsInfoOneLineProperty, value);
            }
        }
        private static void OnIsInfoOneLineChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.IsInfoOneLine = (bool)e.NewValue;
            }
        }
        #endregion


        #region ==PIND===========
        public static readonly DependencyProperty PINDProperty = DependencyProperty.Register("PIND",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnPINDChanged));
        public string PIND
        {
            get
            {
                return (string)GetValue(PINDProperty);
            }
            set
            {
                SetValue(PINDProperty, value);
               
            }
        }
        private static void OnPINDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.PIND = (string)e.NewValue;
                src.TMV.PIND = (string)e.NewValue;
                src.PINDLOAD((string)e.NewValue);

                //src.Dispatcher.BeginInvoke(DispatcherPriority.Background, new EXAUFDelegate(src.PINDLOAD), (string)e.NewValue);
            }
        }
        #endregion

        #region ==TP===========
        public static readonly DependencyProperty TPProperty = DependencyProperty.Register("TP",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTPChanged));
        public string TP
        {
            get
            {
                return (string)GetValue(TPProperty);
            }
            set
            {
                SetValue(TPProperty, value);
                if (MV == null) return;
                TMV.TP = value;
            }
        }
        private static void OnTPChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TP = (string)e.NewValue;
            }
        }
        #endregion

        #region ==TATR===========
        public static readonly DependencyProperty TATRProperty = DependencyProperty.Register("TATR",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTATRChanged));
        public string TATR
        {
            get
            {
                return (string)GetValue(TATRProperty);
            }
            set
            {
                SetValue(TATRProperty, value);
            }
        }
        private static void OnTATRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TATR = (string)e.NewValue;
            }
        }
        #endregion

        #region ==TATR0===========
        public static readonly DependencyProperty TATR0Property = DependencyProperty.Register("TATR0",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTATR0Changed));
        public string TATR0
        {
            get
            {
                return (string)GetValue(TATR0Property);
            }
            set
            {
                SetValue(TATR0Property, value);
            }
        }
        private static void OnTATR0Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TATR0 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TATR1===========
        public static readonly DependencyProperty TATR1Property = DependencyProperty.Register("TATR1",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTATR1Changed));
        public string TATR1
        {
            get
            {
                return (string)GetValue(TATR1Property);
            }
            set
            {
                SetValue(TATR1Property, value);
            }
        }
        private static void OnTATR1Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TATR1 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TATR2===========
        public static readonly DependencyProperty TATR2Property = DependencyProperty.Register("TATR2",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTATR2Changed));
        public string TATR2
        {
            get
            {
                return (string)GetValue(TATR2Property);
            }
            set
            {
                SetValue(TATR2Property, value);
            }
        }
        private static void OnTATR2Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TATR2 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TATR3===========
        public static readonly DependencyProperty TATR3Property = DependencyProperty.Register("TATR3",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTATR3Changed));
        public string TATR3
        {
            get
            {
                return (string)GetValue(TATR3Property);
            }
            set
            {
                SetValue(TATR3Property, value);
            }
        }
        private static void OnTATR3Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TATR3 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TATR4===========
        public static readonly DependencyProperty TATR4Property = DependencyProperty.Register("TATR4",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTATR4Changed));
        public string TATR4
        {
            get
            {
                return (string)GetValue(TATR4Property);
            }
            set
            {
                SetValue(TATR4Property, value);
            }
        }
        private static void OnTATR4Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TATR4 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TATR5===========
        public static readonly DependencyProperty TATR5Property = DependencyProperty.Register("TATR5",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTATR5Changed));
        public string TATR5
        {
            get
            {
                return (string)GetValue(TATR5Property);
            }
            set
            {
                SetValue(TATR5Property, value);
            }
        }
        private static void OnTATR5Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TATR5 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TATR6===========
        public static readonly DependencyProperty TATR6Property = DependencyProperty.Register("TATR6",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTATR6Changed));
        public string TATR6
        {
            get
            {
                return (string)GetValue(TATR6Property);
            }
            set
            {
                SetValue(TATR6Property, value);
            }
        }
        private static void OnTATR6Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TATR6 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TATR7===========
        public static readonly DependencyProperty TATR7Property = DependencyProperty.Register("TATR7",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTATR7Changed));
        public string TATR7
        {
            get
            {
                return (string)GetValue(TATR7Property);
            }
            set
            {
                SetValue(TATR7Property, value);
            }
        }
        private static void OnTATR7Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TATR7 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TATR8===========
        public static readonly DependencyProperty TATR8Property = DependencyProperty.Register("TATR8",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTATR8Changed));
        public string TATR8
        {
            get
            {
                return (string)GetValue(TATR8Property);
            }
            set
            {
                SetValue(TATR8Property, value);
            }
        }
        private static void OnTATR8Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TATR8 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TATR9===========
        public static readonly DependencyProperty TATR9Property = DependencyProperty.Register("TATR9",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTATR9Changed));
        public string TATR9
        {
            get
            {
                return (string)GetValue(TATR9Property);
            }
            set
            {
                SetValue(TATR9Property, value);
            }
        }
        private static void OnTATR9Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TATR9 = (string)e.NewValue;
            }
        }
        #endregion

        #region ==TATRA===========
        public static readonly DependencyProperty TATRAProperty = DependencyProperty.Register("TATRA",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTATRAChanged));
        public string TATRA
        {
            get
            {
                return (string)GetValue(TATRAProperty);
            }
            set
            {
                SetValue(TATRAProperty, value);
            }
        }
        private static void OnTATRAChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TATRA = (string)e.NewValue;
            }
        }
        #endregion

        #region ==TA01===========
        public static readonly DependencyProperty TA01Property = DependencyProperty.Register("TA01",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA01Changed));
        public string TA01
        {
            get
            {
                return (string)GetValue(TA01Property);
            }
            set
            {
                SetValue(TA01Property, value);
            }
        }
        private static void OnTA01Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA01 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA11===========
        public static readonly DependencyProperty TA11Property = DependencyProperty.Register("TA11",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA11Changed));
        public string TA11
        {
            get
            {
                return (string)GetValue(TA11Property);
            }
            set
            {
                SetValue(TA11Property, value);
            }
        }
        private static void OnTA11Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA11 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA21===========
        public static readonly DependencyProperty TA21Property = DependencyProperty.Register("TA21",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA21Changed));
        public string TA21
        {
            get
            {
                return (string)GetValue(TA21Property);
            }
            set
            {
                SetValue(TA21Property, value);
            }
        }
        private static void OnTA21Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA21 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA31===========
        public static readonly DependencyProperty TA31Property = DependencyProperty.Register("TA31",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA31Changed));
        public string TA31
        {
            get
            {
                return (string)GetValue(TA31Property);
            }
            set
            {
                SetValue(TA31Property, value);
            }
        }
        private static void OnTA31Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA31 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA41===========
        public static readonly DependencyProperty TA41Property = DependencyProperty.Register("TA41",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA41Changed));
        public string TA41
        {
            get
            {
                return (string)GetValue(TA41Property);
            }
            set
            {
                SetValue(TA41Property, value);
            }
        }
        private static void OnTA41Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA41 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA51===========
        public static readonly DependencyProperty TA51Property = DependencyProperty.Register("TA51",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA51Changed));
        public string TA51
        {
            get
            {
                return (string)GetValue(TA51Property);
            }
            set
            {
                SetValue(TA51Property, value);
            }
        }
        private static void OnTA51Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA51 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA61===========
        public static readonly DependencyProperty TA61Property = DependencyProperty.Register("TA61",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA61Changed));
        public string TA61
        {
            get
            {
                return (string)GetValue(TA61Property);
            }
            set
            {
                SetValue(TA61Property, value);
            }
        }
        private static void OnTA61Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA61 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA71===========
        public static readonly DependencyProperty TA71Property = DependencyProperty.Register("TA71",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA71Changed));
        public string TA71
        {
            get
            {
                return (string)GetValue(TA71Property);
            }
            set
            {
                SetValue(TA71Property, value);
            }
        }
        private static void OnTA71Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA71 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA81===========
        public static readonly DependencyProperty TA81Property = DependencyProperty.Register("TA81",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA81Changed));
        public string TA81
        {
            get
            {
                return (string)GetValue(TA81Property);
            }
            set
            {
                SetValue(TA81Property, value);
            }
        }
        private static void OnTA81Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA81 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA91===========
        public static readonly DependencyProperty TA91Property = DependencyProperty.Register("TA91",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA91Changed));
        public string TA91
        {
            get
            {
                return (string)GetValue(TA91Property);
            }
            set
            {
                SetValue(TA91Property, value);
            }
        }
        private static void OnTA91Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA91 = (string)e.NewValue;
            }
        }
        #endregion

        #region ==TAA1===========
        public static readonly DependencyProperty TAA1Property = DependencyProperty.Register("TAA1",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTAA1Changed));
        public string TAA1
        {
            get
            {
                return (string)GetValue(TAA1Property);
            }
            set
            {
                SetValue(TAA1Property, value);
            }
        }
        private static void OnTAA1Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TAA1 = (string)e.NewValue;
            }
        }
        #endregion


        #region ==TA02===========
        public static readonly DependencyProperty TA02Property = DependencyProperty.Register("TA02",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA02Changed));
        public string TA02
        {
            get
            {
                return (string)GetValue(TA02Property);
            }
            set
            {
                SetValue(TA02Property, value);
                OnTEXTChg("TA02", value);
            }
        }
        private static void OnTA02Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA02 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA12===========
        public static readonly DependencyProperty TA12Property = DependencyProperty.Register("TA12",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA12Changed));
        public string TA12
        {
            get
            {
                return (string)GetValue(TA12Property);
            }
            set
            {
                SetValue(TA12Property, value);
                OnTEXTChg("TA12", value);
            }
        }
        private static void OnTA12Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA12 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA22===========
        public static readonly DependencyProperty TA22Property = DependencyProperty.Register("TA22",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA22Changed));
        public string TA22
        {
            get
            {
                return (string)GetValue(TA22Property);
            }
            set
            {
                SetValue(TA22Property, value);
                OnTEXTChg("TA22", value);
            }
        }
        private static void OnTA22Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA22 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA32===========
        public static readonly DependencyProperty TA32Property = DependencyProperty.Register("TA32",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA32Changed));
        public string TA32
        {
            get
            {
                return (string)GetValue(TA32Property);
            }
            set
            {
                SetValue(TA32Property, value);
                OnTEXTChg("TA32", value);
            }
        }
        private static void OnTA32Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA32 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA42===========
        public static readonly DependencyProperty TA42Property = DependencyProperty.Register("TA42",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA42Changed));
        public string TA42
        {
            get
            {
                return (string)GetValue(TA42Property);
            }
            set
            {
                SetValue(TA42Property, value);
                OnTEXTChg("TA42", value);
            }
        }
        private static void OnTA42Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA42 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA52===========
        public static readonly DependencyProperty TA52Property = DependencyProperty.Register("TA52",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA52Changed));
        public string TA52
        {
            get
            {
                return (string)GetValue(TA52Property);
            }
            set
            {
                SetValue(TA52Property, value);
                OnTEXTChg("TA52", value);
            }
        }
        private static void OnTA52Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA52 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA62===========
        public static readonly DependencyProperty TA62Property = DependencyProperty.Register("TA62",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA62Changed));
        public string TA62
        {
            get
            {
                return (string)GetValue(TA62Property);
            }
            set
            {
                SetValue(TA62Property, value);
                OnTEXTChg("TA62", value);
            }
        }
        private static void OnTA62Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA62 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA72===========
        public static readonly DependencyProperty TA72Property = DependencyProperty.Register("TA72",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA72Changed));
        public string TA72
        {
            get
            {
                return (string)GetValue(TA72Property);
            }
            set
            {
                SetValue(TA72Property, value);
                OnTEXTChg("TA72", value);
            }
        }
        private static void OnTA72Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA72 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA82===========
        public static readonly DependencyProperty TA82Property = DependencyProperty.Register("TA82",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA82Changed));
        public string TA82
        {
            get
            {
                return (string)GetValue(TA82Property);
            }
            set
            {
                SetValue(TA82Property, value);
                OnTEXTChg("TA82", value);
            }
        }
        private static void OnTA82Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA82 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA92===========
        public static readonly DependencyProperty TA92Property = DependencyProperty.Register("TA92",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA92Changed));
        public string TA92
        {
            get
            {
                return (string)GetValue(TA92Property);
            }
            set
            {
                SetValue(TA92Property, value);
                OnTEXTChg("TA92", value);
            }
        }
        private static void OnTA92Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA92 = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TAA2===========
        public static readonly DependencyProperty TAA2Property = DependencyProperty.Register("TAA2",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTAA2Changed));
        public string TAA2
        {
            get
            {
                return (string)GetValue(TAA2Property);
            }
            set
            {
                SetValue(TAA2Property, value);
                OnTEXTChg("TAA2", value);
            }
        }
        private static void OnTAA2Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TAA2 = (string)e.NewValue;
            }
        }
        #endregion

        #region ==TA01PD===========
        public static readonly DependencyProperty TA01PDProperty = DependencyProperty.Register("TA01PD",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA01PDChanged));
        public string TA01PD
        {
            get
            {
                return (string)GetValue(TA01PDProperty);
            }
            set
            {
                SetValue(TA01PDProperty, value);
                OnPDChg("TA01PD", value);
            }
        }
        private static void OnTA01PDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA01PD = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA11PD===========
        public static readonly DependencyProperty TA11PDProperty = DependencyProperty.Register("TA11PD",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA11PDChanged));
        public string TA11PD
        {
            get
            {
                return (string)GetValue(TA11PDProperty);
            }
            set
            {
                SetValue(TA11PDProperty, value);
                OnPDChg("TA11PD", value);
            }
        }
        private static void OnTA11PDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA11PD = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA21PD===========
        public static readonly DependencyProperty TA21PDProperty = DependencyProperty.Register("TA21PD",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA21PDChanged));
        public string TA21PD
        {
            get
            {
                return (string)GetValue(TA21PDProperty);
            }
            set
            {
                SetValue(TA21PDProperty, value);
                OnPDChg("TA21PD", value);
            }
        }
        private static void OnTA21PDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA21PD = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA31PD===========
        public static readonly DependencyProperty TA31PDProperty = DependencyProperty.Register("TA31PD",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA31PDChanged));
        public string TA31PD
        {
            get
            {
                return (string)GetValue(TA31PDProperty);
            }
            set
            {
                SetValue(TA31PDProperty, value);
                OnPDChg("TA31PD", value);
            }
        }
        private static void OnTA31PDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA31PD = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA41PD===========
        public static readonly DependencyProperty TA41PDProperty = DependencyProperty.Register("TA41PD",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA41PDChanged));
        public string TA41PD
        {
            get
            {
                return (string)GetValue(TA41PDProperty);
            }
            set
            {
                SetValue(TA41PDProperty, value);
                OnPDChg("TA41PD", value);
            }
        }
        private static void OnTA41PDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA41PD = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA51PD===========
        public static readonly DependencyProperty TA51PDProperty = DependencyProperty.Register("TA51PD",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA51PDChanged));
        public string TA51PD
        {
            get
            {
                return (string)GetValue(TA51PDProperty);
            }
            set
            {
                SetValue(TA51PDProperty, value);
                OnPDChg("TA51PD", value);
            }
        }
        private static void OnTA51PDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA51PD = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA61PD===========
        public static readonly DependencyProperty TA61PDProperty = DependencyProperty.Register("TA61PD",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA61PDChanged));
        public string TA61PD
        {
            get
            {
                return (string)GetValue(TA61PDProperty);
            }
            set
            {
                SetValue(TA61PDProperty, value);
                OnPDChg("TA61PD", value);
            }
        }
        private static void OnTA61PDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA61PD = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA71PD===========
        public static readonly DependencyProperty TA71PDProperty = DependencyProperty.Register("TA71PD",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA71PDChanged));
        public string TA71PD
        {
            get
            {
                return (string)GetValue(TA71PDProperty);
            }
            set
            {
                SetValue(TA71PDProperty, value);
                OnPDChg("TA71PD", value);
            }
        }
        private static void OnTA71PDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA71PD = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA81PD===========
        public static readonly DependencyProperty TA81PDProperty = DependencyProperty.Register("TA81PD",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA81PDChanged));
        public string TA81PD
        {
            get
            {
                return (string)GetValue(TA81PDProperty);
            }
            set
            {
                SetValue(TA81PDProperty, value);
                OnPDChg("TA81PD", value);
            }
        }
        private static void OnTA81PDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA81PD = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA91PD===========
        public static readonly DependencyProperty TA91PDProperty = DependencyProperty.Register("TA91PD",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA91PDChanged));
        public string TA91PD
        {
            get
            {
                return (string)GetValue(TA91PDProperty);
            }
            set
            {
                SetValue(TA91PDProperty, value);
                OnPDChg("TA91PD", value);
            }
        }
        private static void OnTA91PDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA91PD = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TAA1PD===========
        public static readonly DependencyProperty TAA1PDProperty = DependencyProperty.Register("TAA1PD",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTAA1PDChanged));
        public string TAA1PD
        {
            get
            {
                return (string)GetValue(TAA1PDProperty);
            }
            set
            {
                SetValue(TAA1PDProperty, value);
                OnPDChg("TAA1PD", value);
            }
        }
        private static void OnTAA1PDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TAA1PD = (string)e.NewValue;
            }
        }
        #endregion


        #region ==TA01S===========
        public static readonly DependencyProperty TA01SProperty = DependencyProperty.Register("TA01S",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA01SChanged));
        public string TA01S
        {
            get
            {
                return (string)GetValue(TA01SProperty);
            }
            set
            {
                SetValue(TA01SProperty, value);
                OnTA01SChg(value);
            }
        }
        private static void OnTA01SChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA01S = (string)e.NewValue;
            }
        }
        public virtual void OnTA01SChg(string value)
        { }
        #endregion
        #region ==TA11S===========
        public static readonly DependencyProperty TA11SProperty = DependencyProperty.Register("TA11S",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA11SChanged));
        public string TA11S
        {
            get
            {
                return (string)GetValue(TA11SProperty);
            }
            set
            {
                SetValue(TA11SProperty, value);
                OnTA11SChg(value);
            }
        }
        private static void OnTA11SChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA11S = (string)e.NewValue;
            }
        }
        public virtual void OnTA11SChg(string value)
        { }
        #endregion
        #region ==TA21S===========
        public static readonly DependencyProperty TA21SProperty = DependencyProperty.Register("TA21S",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA21SChanged));
        public string TA21S
        {
            get
            {
                return (string)GetValue(TA21SProperty);
            }
            set
            {
                SetValue(TA21SProperty, value);
                OnTA21SChg(value);
            }
        }
        private static void OnTA21SChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA21S = (string)e.NewValue;
            }
        }
        public virtual void OnTA21SChg(string value)
        { }
        #endregion
        #region ==TA31S===========
        public static readonly DependencyProperty TA31SProperty = DependencyProperty.Register("TA31S",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA31SChanged));
        public string TA31S
        {
            get
            {
                return (string)GetValue(TA31SProperty);
            }
            set
            {
                SetValue(TA31SProperty, value);
                OnTA31SChg(value);
            }
        }
        private static void OnTA31SChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA31S = (string)e.NewValue;
            }
        }
        public virtual void OnTA31SChg(string value)
        { }
        #endregion
        #region ==TA41S===========
        public static readonly DependencyProperty TA41SProperty = DependencyProperty.Register("TA41S",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA41SChanged));
        public string TA41S
        {
            get
            {
                return (string)GetValue(TA41SProperty);
            }
            set
            {
                SetValue(TA41SProperty, value);
                OnTA41SChg(value);
            }
        }
        private static void OnTA41SChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA41S = (string)e.NewValue;
            }
        }
        public virtual void OnTA41SChg(string value)
        { }
        #endregion
        #region ==TA51S===========
        public static readonly DependencyProperty TA51SProperty = DependencyProperty.Register("TA51S",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA51SChanged));
        public string TA51S
        {
            get
            {
                return (string)GetValue(TA51SProperty);
            }
            set
            {
                SetValue(TA51SProperty, value);
                OnTA51SChg(value);
            }
        }
        private static void OnTA51SChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA51S = (string)e.NewValue;
            }
        }
        public virtual void OnTA51SChg(string value)
        { }
        #endregion
        #region ==TA61S===========
        public static readonly DependencyProperty TA61SProperty = DependencyProperty.Register("TA61S",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA61SChanged));
        public string TA61S
        {
            get
            {
                return (string)GetValue(TA61SProperty);
            }
            set
            {
                SetValue(TA61SProperty, value);
                OnTA61SChg(value);
            }
        }
        public virtual void OnTA61SChg(string value)
        { }
        private static void OnTA61SChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA61S = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA71S===========
        public static readonly DependencyProperty TA71SProperty = DependencyProperty.Register("TA71S",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA71SChanged));
        public string TA71S
        {
            get
            {
                return (string)GetValue(TA71SProperty);
            }
            set
            {
                SetValue(TA71SProperty, value);
                OnTA71SChg(value);
            }
        }
        private static void OnTA71SChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA71S = (string)e.NewValue;
            }
        }
        public virtual void OnTA71SChg(string value)
        { }
        #endregion
        #region ==TA81S===========
        public static readonly DependencyProperty TA81SProperty = DependencyProperty.Register("TA81S",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA81SChanged));
        public string TA81S
        {
            get
            {
                return (string)GetValue(TA81SProperty);
            }
            set
            {
                SetValue(TA81SProperty, value);
                OnTA81SChg(value);
            }
        }
        private static void OnTA81SChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA81S = (string)e.NewValue;
            }
        }
        public virtual void OnTA81SChg(string value)
        { }
        #endregion
        #region ==TA91S===========
        public static readonly DependencyProperty TA91SProperty = DependencyProperty.Register("TA91S",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA91SChanged));
        public string TA91S
        {
            get
            {
                return (string)GetValue(TA91SProperty);
            }
            set
            {
                SetValue(TA91SProperty, value);
                OnTA91SChg(value);
            }
        }
        private static void OnTA91SChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA91S = (string)e.NewValue;
            }
        }
        public virtual void OnTA91SChg(string value)
        { }
        #endregion

        #region ==TAA1S===========
        public static readonly DependencyProperty TAA1SProperty = DependencyProperty.Register("TAA1S",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTAA1SChanged));
        public string TAA1S
        {
            get
            {
                return (string)GetValue(TAA1SProperty);
            }
            set
            {
                SetValue(TAA1SProperty, value);
                OnTAA1SChg(value);
            }
        }
        private static void OnTAA1SChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TAA1S = (string)e.NewValue;
            }
        }
        public virtual void OnTAA1SChg(string value)
        { }
        #endregion


        #region ==TA01DT===========
        public static readonly DependencyProperty TA01DTProperty = DependencyProperty.Register("TA01DT",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA01DTChanged));
        public string TA01DT
        {
            get
            {
                return (string)GetValue(TA01DTProperty);
            }
            set
            {
                SetValue(TA01DTProperty, value);
                OnTA01DTChg(value);
            }
        }
        private static void OnTA01DTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA01DT = (string)e.NewValue;
            }
        }
        public virtual void OnTA01DTChg(string value)
        { }

        #endregion
        #region ==TA11DT===========
        public static readonly DependencyProperty TA11DTProperty = DependencyProperty.Register("TA11DT",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA11DTChanged));
        public string TA11DT
        {
            get
            {
                return (string)GetValue(TA11DTProperty);
            }
            set
            {
                SetValue(TA11DTProperty, value);
                OnTA11DTChg(value);
            }
        }
        private static void OnTA11DTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA11DT = (string)e.NewValue;
            }
        }
        public virtual void OnTA11DTChg(string value)
        { }
        #endregion
        #region ==TA21DT===========
        public static readonly DependencyProperty TA21DTProperty = DependencyProperty.Register("TA21DT",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA21DTChanged));
        public string TA21DT
        {
            get
            {
                return (string)GetValue(TA21DTProperty);
            }
            set
            {
                SetValue(TA21DTProperty, value);
                OnTA21DTChg(value);
            }
        }
        private static void OnTA21DTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA21DT = (string)e.NewValue;
            }
        }
        public virtual void OnTA21DTChg(string value)
        { }
        #endregion
        #region ==TA31DT===========
        public static readonly DependencyProperty TA31DTProperty = DependencyProperty.Register("TA31DT",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA31DTChanged));
        public string TA31DT
        {
            get
            {
                return (string)GetValue(TA31DTProperty);
            }
            set
            {
                SetValue(TA31DTProperty, value);
                OnTA31DTChg(value);
            }
        }
        public virtual void OnTA31DTChg(string value)
        { }
        private static void OnTA31DTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA31DT = (string)e.NewValue;
            }
        }

        #endregion
        #region ==TA41DT===========
        public static readonly DependencyProperty TA41DTProperty = DependencyProperty.Register("TA41DT",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA41DTChanged));
        public string TA41DT
        {
            get
            {
                return (string)GetValue(TA41DTProperty);
            }
            set
            {
                SetValue(TA41DTProperty, value);
                OnTA41DTChg(value);
            }
        }
        public virtual void OnTA41DTChg(string value)
        { }
        private static void OnTA41DTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA41DT = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA51DT===========
        public static readonly DependencyProperty TA51DTProperty = DependencyProperty.Register("TA51DT",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA51DTChanged));
        public string TA51DT
        {
            get
            {
                return (string)GetValue(TA51DTProperty);
            }
            set
            {
                SetValue(TA51DTProperty, value);
                OnTA51DTChg(value);
            }
        }
        public virtual void OnTA51DTChg(string value)
        { }
        private static void OnTA51DTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA51DT = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA61DT===========
        public static readonly DependencyProperty TA61DTProperty = DependencyProperty.Register("TA61DT",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA61DTChanged));
        public string TA61DT
        {
            get
            {
                return (string)GetValue(TA61DTProperty);
            }
            set
            {
                SetValue(TA61DTProperty, value);
                OnTA61DTChg(value);
            }
        }
        public virtual void OnTA61DTChg(string value)
        { }
        private static void OnTA61DTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA61DT = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA71DT===========
        public static readonly DependencyProperty TA71DTProperty = DependencyProperty.Register("TA71DT",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA71DTChanged));
        public string TA71DT
        {
            get
            {
                return (string)GetValue(TA71DTProperty);
            }
            set
            {
                SetValue(TA71DTProperty, value);
                OnTA71DTChg(value);
            }
        }
        public virtual void OnTA71DTChg(string value)
        { }
        private static void OnTA71DTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA71DT = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA81DT===========
        public static readonly DependencyProperty TA81DTProperty = DependencyProperty.Register("TA81DT",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA81DTChanged));
        public string TA81DT
        {
            get
            {
                return (string)GetValue(TA81DTProperty);
            }
            set
            {
                SetValue(TA81DTProperty, value);
                OnTA81DTChg(value);
            }
        }
        public virtual void OnTA81DTChg(string value)
        { }
        private static void OnTA81DTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA81DT = (string)e.NewValue;
            }
        }
        #endregion
        #region ==TA91DT===========
        public static readonly DependencyProperty TA91DTProperty = DependencyProperty.Register("TA91DT",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTA91DTChanged));
        public string TA91DT
        {
            get
            {
                return (string)GetValue(TA91DTProperty);
            }
            set
            {
                SetValue(TA91DTProperty, value);
                OnTA91DTChg(value);
            }
        }
        public virtual void OnTA91DTChg(string value)
        { }
        private static void OnTA91DTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TA91DT = (string)e.NewValue;
            }
        }
        #endregion

        #region ==TAA1DT===========
        public static readonly DependencyProperty TAA1DTProperty = DependencyProperty.Register("TAA1DT",
        typeof(string), typeof(UITXTKON),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTAA1DTChanged));
        public string TAA1DT
        {
            get
            {
                return (string)GetValue(TAA1DTProperty);
            }
            set
            {
                SetValue(TAA1DTProperty, value);
                OnTAA1DTChg(value);
            }
        }
        public virtual void OnTAA1DTChg(string value)
        { }
        private static void OnTAA1DTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UITXTKON;
            if (src != null)
            {
                src.TAA1DT = (string)e.NewValue;
            }
        }
        #endregion


        public UITXTKON()
        {
            if (DesignerProperties.GetIsInDesignMode(this))
                return;

        }

        public override void Window_Loaded(object sender, RoutedEventArgs e)
        {
            if (DesignerProperties.GetIsInDesignMode(this))
                return;
            if (IsLoaded)
                return;
            base.Window_Loaded(sender, e);
        }

        public void txt_KeyUp(object sender, KeyEventArgs e)
        {
            try
            {
                if (e.Key != System.Windows.Input.Key.Enter)
                    return;
                TextBox tb = sender as TextBox;
                this.Focus();
                if (tb.Text.Trim().Length == tb.MaxLength)
                {
                    TMV.InsertLine("");
                }
                TMV.POSTCHG();
                vwMaster.View.MoveCurrentToLast();
            }
            catch (Exception ex)
            {
                Tracer.Error(ex.StackTrace, ex);
            }
        }

        public override void vwMaster_CurrentChanged(object sender, EventArgs e)
        {
            base.vwMaster_CurrentChanged(sender, e);
        }

        public virtual void OnTEXTChg(string txttp, string txt)
        {
            switch (txttp)
            {
                case "TA02":
                    SetTPTxt("00", txt);
                    break;
                case "TA12":
                    SetTPTxt("01", txt);
                    break;
                case "TA22":
                    SetTPTxt("02", txt);
                    break;
                case "TA32":
                    SetTPTxt("03", txt);
                    break;
                case "TA42":
                    SetTPTxt("04", txt);
                    break;
                case "TA52":
                    SetTPTxt("05", txt);
                    break;
                case "TA62":
                    SetTPTxt("06", txt);
                    break;
                case "TA72":
                    SetTPTxt("07", txt);
                    break;
                case "TA82":
                    SetTPTxt("08", txt);
                    break;
                case "TA92":
                    SetTPTxt("09", txt);
                    break;
                case "TAA2":
                    SetTPTxt("10", txt);
                    break;
            }
        }

        public virtual void OnPDChg(string txttp, string txt)
        {
            switch (txttp)
            {
                case "TA01PD":
                    SetTPPD("0", txt);
                    break;
                case "TA11PD":
                    SetTPPD("1", txt);
                    break;
                case "TA21PD":
                    SetTPPD("2", txt);
                    break;
                case "TA31PD":
                    SetTPPD("3", txt);
                    break;
                case "TA41PD":
                    SetTPPD("4", txt);
                    break;
                case "TA51PD":
                    SetTPPD("5", txt);
                    break;
                case "TA61PD":
                    SetTPPD("6", txt);
                    break;
                case "TA71PD":
                    SetTPPD("7", txt);
                    break;
                case "TA81PD":
                    SetTPPD("8", txt);
                    break;
                case "TA91PD":
                    SetTPPD("9", txt);
                    break;

            }
        }

        public void InsertLine(string txt)
        {
            TMV.InsertLine(txt);
            TMV.POSTCHG();
            vwMaster.View.MoveCurrentToLast();
        }

        public void ReSetTXT()
        {
            TATR0 = "0000";
            TATR1 = "0000";
            TATR2 = "0000";
            TATR3 = "0000";
            TATR4 = "0000";
            TATR5 = "0000";
            TATR6 = "0000";
            TATR7 = "0000";
            TATR8 = "0000";
            TATR9 = "0000";


            TA01 = "".PadRight(4);
            TA11 = "".PadRight(4);
            TA21 = "".PadRight(4);
            TA31 = "".PadRight(4);
            TA41 = "".PadRight(4);
            TA51 = "".PadRight(4);
            TA61 = "".PadRight(4);
            TA71 = "".PadRight(4);
            TA81 = "".PadRight(4);
            TA91 = "".PadRight(4);


            TA02 = "".PadRight(126);
            TA12 = "".PadRight(126);
            TA22 = "".PadRight(126);
            TA32 = "".PadRight(126);
            TA42 = "".PadRight(126);
            TA52 = "".PadRight(126);
            TA62 = "".PadRight(126);
            TA72 = "".PadRight(126);
            TA82 = "".PadRight(126);
            TA92 = "".PadRight(126);


            TA01PD = "".PadRight(4);
            TA11PD = "".PadRight(4);
            TA21PD = "".PadRight(4);
            TA31PD = "".PadRight(4);
            TA41PD = "".PadRight(4);
            TA51PD = "".PadRight(4);
            TA61PD = "".PadRight(4);
            TA71PD = "".PadRight(4);
            TA81PD = "".PadRight(4);
            TA91PD = "".PadRight(4);


            TA01S = "".PadRight(8);
            TA11S = "".PadRight(8);
            TA21S = "".PadRight(8);
            TA31S = "".PadRight(8);
            TA41S = "".PadRight(8);
            TA51S = "".PadRight(8);
            TA61S = "".PadRight(8);
            TA71S = "".PadRight(8);
            TA81S = "".PadRight(8);
            TA91S = "".PadRight(8);


            TA01DT = "".PadRight(8);
            TA11DT = "".PadRight(8);
            TA21DT = "".PadRight(8);
            TA31DT = "".PadRight(8);
            TA41DT = "".PadRight(8);
            TA51DT = "".PadRight(8);
            TA61DT = "".PadRight(8);
            TA71DT = "".PadRight(8);
            TA81DT = "".PadRight(8);
            TA91DT = "".PadRight(8);



        }

        public virtual void PINDLOAD(string pind)
        {
            try
            {
                TBMain.Clear();
                INFO = "";
                if (pind.Length == 0)
                {
                    return;
                }
                dwData = TBMain.NewRow();
                dwData["TXTKMANDANT"] = app.Mandant;
                dwData["TXTKPIND"] = pind;
                SResult = TMV.QTXT05(dwData);
                MergeData(SResult, true, true);
                GetInfo();
                if (!IsEdit)
                    return;
                if (TBMain.Rows.Count == 0)
                {
                    if (DEFTXT == null)
                    {
                        InsertLine("");
                        return;
                    }
                    if (DEFTXT.Count == 0)
                    {
                        InsertLine("");
                        return;
                    }
                    foreach (string str in DEFTXT)//如果存在预定义文本，则逐行插入
                    {
                        InsertLine(Helper.ConvertGB2312To8859P1(str));
                    }
                }
            }
            catch (Exception ex)
            {
                Tracer.Error(ex.StackTrace, ex);
            }
        }

        public void GetInfo()
        {
            INFO = "";
            foreach (DataRow row in TBMain.Rows)
            {
                if (!IsInfoOneLine)
                {
                    INFO += row["TXTKTEXT"].ToString().Trim() + Environment.NewLine;
                }
                else
                {
                    INFO += row["TXTKTEXT"].ToString().Trim() + ",";
                }
            }


            if (!IsInfoOneLine)
                return;
            int leng = INFO.Length;
            if (leng > 0)
            {
                INFO += "****";
                INFO = INFO.Replace(",****", "").Replace("''", "'");
            }
        }

        public void SaveTXT()
        {
            if (PIND == "")
                return;
            if(IsTXTBox)
            {
                TMV.PushText(PIND, INFO, true);

            }
            else
            {
                TMV.PushText(PIND, INFO, false); 
            }
            foreach (DataRow row in TBMain.Rows)
            {
                TMV.UpdateTXTKON(row, app.company);
            }
            GetInfo();
        }

        public override void OnSave()
        {
            if (!IsSaved)
                return;
            SaveTXT();
            base.OnSave();
        }

        public override void NewCommand(object sender, RoutedEventArgs e)
        {
            InsertLine("");
        }

        private void SetPos(string atr, DataRow[] rowss, int x)
        {
            TP = "";
            TP = rowss[x]["TXTKFILLER"].ToString();
            string _atr = Helper.Right("0000" + rowss[x]["TXTKATR"].ToString(), 4);
            string pd = rowss[x]["TXTKTEXT"].ToString().Substring(0, 4).PadRight(4);
            string dt = rowss[x]["TXTKTEXT"].ToString().Substring(4, 8);
            string sn = rowss[x]["TXTKTEXT"].ToString().Substring(12, 8);
            string txt = (rowss[x]["TXTKTEXT"].ToString().Substring(20).Trim() + rowss[x + 1]["TXTKTEXT"].ToString().Trim()).PadRight(126);
            switch (atr)
            {
                case "00":
                    TATR0 = _atr;
                    TA01PD = pd;
                    TA01S = sn;
                    TA01DT = dt;
                    TA01 = txt;
                    break;
                case "01":
                    TATR1 = _atr;
                    TA11PD = pd;
                    TA11S = sn;
                    TA11DT = dt;
                    TA12 = txt;
                    break;
                case "02":
                    TATR2 = _atr;
                    TA21PD = pd;
                    TA21S = sn;
                    TA21DT = dt;
                    TA22 = txt;
                    break;
                case "03":
                    TATR3 = _atr;
                    TA31PD = pd;
                    TA31S = sn;
                    TA31DT = dt;
                    TA32 = txt;
                    break;
                case "04":
                    TATR4 = _atr;
                    TA41PD = pd;
                    TA41S = sn;
                    TA41DT = dt;
                    TA42 = txt;
                    break;
                case "05":
                    TATR5 = _atr;
                    TA51PD = pd;
                    TA51S = sn;
                    TA51DT = dt;
                    TA52 = txt;
                    break;
                case "06":
                    TATR6 = _atr;
                    TA61PD = pd;
                    TA61S = sn;
                    TA61DT = dt;
                    TA62 = txt;
                    break;
                case "07":
                    TATR7 = _atr;
                    TA71PD = pd;
                    TA71S = sn;
                    TA71DT = dt;
                    TA72 = txt;
                    break;
                case "08":
                    TATR8 = _atr;
                    TA81PD = pd;
                    TA81S = sn;
                    TA81DT = dt;
                    TA82 = txt;
                    break;
                case "09":
                    TATR9 = _atr;
                    TA91PD = pd;
                    TA91S = sn;
                    TA91DT = dt;
                    TA92 = txt;
                    break;
                case "10":
                    TATRA = _atr;
                    TAA1PD = pd;
                    TAA1S = sn;
                    TAA1DT = dt;
                    TAA2 = txt;
                    break;
            }
        }

        public void GetTPTxt()
        {
            filter = "TXTKFILLER='" + TP + "'";
            sort = " TXTKPIND ASC,TXTKPOS ASC,TXTKATR ASC";
            DataRow[] rowss = TBMain.Select(filter, sort);
            int count = rowss.Length;
            string atr = "";
            for (int x = 0; x < count; x++)
            {
                atr = Helper.Right("0000" + rowss[x]["TXTKATR"].ToString(), 4);
                SetPos(atr.Substring(2, 2), rowss, x);
                x++;
            }
            GetInfo();
        }

        public void SetTPTxt(string _atr, string txt)
        {
            try
            {
                if (!IsEdit)
                    return;
                filter = "TXTKFILLER='" + TP + "' AND Convert(TXTKATR,'System.String') LIKE '%" + _atr + "'";
                sort = " TXTKPIND ASC,TXTKPOS ASC,TXTKATR ASC";
                DataRow[] rowss = TBMain.Select(filter, sort);
                int count = rowss.Length;
                if (count < 2) return;
                string t1 = rowss[0]["TXTKTEXT"].ToString();
                rowss[0]["TXTKTEXT"] = t1.Substring(0, 20) + txt.Substring(0, (72 - 20));
                rowss[1]["TXTKTEXT"] = txt.Substring(72 - 20);
            }
            catch (Exception ex)
            {
                Tracer.Error(ex.StackTrace, ex);
            }
        }

        public void SetTPPD(string _atr, string txt)
        {
            if (!IsEdit)
                return;
            filter = "TXTKFILLER='" + TP + "' AND Convert(TXTKATR,'System.String') LIKE '%" + _atr + "'";
            sort = " TXTKPIND ASC,TXTKPOS ASC,TXTKATR ASC";
            DataRow[] rowss = TBMain.Select(filter, sort);
            int count = rowss.Length;
            if (count < 2) return;
            string tt = rowss[0]["TXTKTEXT"].ToString();
            rowss[0]["TXTKTEXT"] = txt.PadRight(4) + tt.Substring(4);
        }

        public virtual void TPSave(string date, string user, int start, int end, bool IsDirectSave)
        {
            //if (date.Trim().Length == 0) return;
            //if (user.Trim().Length == 0) return;
            for (int _atr = start; _atr < end; _atr++)
            {
                filter = "TXTKFILLER='" + TP + "' AND Convert(TXTKATR,'System.String') LIKE '%" + _atr + "'";
                sort = " TXTKPIND ASC,TXTKPOS ASC,TXTKATR ASC";
                rows = TBMain.Select(filter, sort);
                int count = rows.Length;
                if (count < 2) continue;
                string txt = rows[0]["TXTKTEXT"].ToString();
                rows[0]["TXTKTEXT"] = (txt.Substring(0, 4) + date + user + txt.Substring(20).Trim()).PadRight(72);
                if (IsDirectSave)
                {
                    TMV.UpdateTXTKON(rows[0], app.company);
                }
            }
        }

        public virtual void DEFTPTEXT()
        {
        }

        public override void EditCommand(object sender, RoutedEventArgs e)
        {
            base.EditCommand(sender, e);
            DEFTPTEXT();
        }
        public override void bgWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            base.bgWorker_DoWork(sender, e);
            TMV.UTXT((DataTable)PM["TB"]);
        }
        public override void SaveCommand(object sender, RoutedEventArgs e)
        {
            TMV.PushText(PIND, INFO);
            PM["TB"] = TBMain.Copy();
            bgWorker.RunWorkerAsync();
            TA11S = app.User;
            TA11DT = MV.date;
            base.SaveCommand(sender, e);
        }
    }
}
